# Arithmetic Operations

In C++ it is easy to do arithmetic calculations. The result of our calculations can be stored in a variable or can be used directly.

For example these two Arduino programs calculate 2+3 and print the value. The first program uses the return of 2+3 directly and passes that value to the println function. The second program first saves the value of 2+3 in an integer value called sum and then prints the value of sum. While they each perform the same task, the second approach is easier to use and understand with different sums.

void setup() 
{
  Serial.begin(9600);
  Serial.println(3+2);
}
void loop() 
{ 
}

void setup() 
{
  Serial.begin(9600);
  int sum = 3+2;
  Serial.println(sum);
}
void loop() 
{ 
}

# Basic Operators

The following operators are used in C++ to do simple arithmetic calculations:

Operation	C++ Operator
Addition	`+`
Subtraction	`-`
Multiplication	`*`
Division	`/`

We can use these operators with numbers directly or we can use them with variables.

int variable1 = 5;
int variable2 = 10;

int sum = variable1 + variable2;

//sum will be equal to 15

We can also use the same variable that we want the value to be stored in. For example

int variable1 = 5;
variable1 = variable1 * 2;
//this line is translated to
//variable1 = 5 * 2; 
//as the value of variable1 at that moment was 5
//variable1 will be equal to 10

Mixing types

What happens if we add integer and float variables together?

int variableInt = 5;
float variableFloat = 1.23;

int sumInt = variableInt + variableFloat;
float sumFloat = variableInt + variableFloat;

Is there a difference in the value of sumInt and sumFloat?

Learn More

variableInt + variableFloat;

will result in a float value of 6.23.

However, when we store the float value 6.23, it depends on the type of variable we are storing the number in. If the type is int like in sumInt then the number will be converted into an integer and the value in sumInt will be 6. If the variable is a float like sumFloat then the number can be stored as-is. And the value of sumFloat will be 6.23.

# Dividing by an Integer

In C++ if we divide an integer by another integer then the result will be an integer value as well. For example:

The output will be 2 and not 2.5

myVariable is an integer and so is 2 so the result of the division will be an integer as well. To fix that, we can divide by a real number instead of an integer. 2.0 is the same value as 2 but in C++ there is a difference. 2 has an integer type and 2.0 has a double type.

What is the double type?

The variable type double is similar to float but it can store a real number with higher precision than float by storing more significant digits.

Similar to how we can declare a variable with the float type

float myFloat = 1.2;

we can declare a double type

double myDouble = 1.2;

# Order of Operations and Parentheses

The order of operations in C++ follows the concept of precedence in arithmetics. For example multiplication has higher precedence than addition.

If two operators are the same precedence then the expression will be evaluated from left to right.

int var = 8 * 2 + 3; // 19
float var2 = 8 * 2.3 / 2; // 9.20
int var3 = 8 / 2 / 4;   // 1

We can also use parentheses to evaluate arithmetic operations before the full expression is evaluated.

int var = 8 * (2 + 3); // 8 * 5 = 40*
int var2 = (2 + 3) * ( (7 * 2) - 15); // -5

# Modulo Operator

The modulo operator is represented by %, it is an arithmetic operator that returns the remainder of an integer division.

int remainder = 10 % 4; // 2

Exercise

Run the following example and see if you can determine a correlation between the output and the numbers used.

Answer

If a number is divisible by 2 then the remainder will be 0. And if it is not divisible by 2 then the remainder will be 1. If we want to check if an integer is even or odd, we can calculate number % 2 and check if the answer is 1 or 0.

# Compound Assignment

We have already seen how to assign a value to a variable:

int var = 2;

And we have also seen how we can use the variable to do arithmetic operation on it and then save it to the same variable:

int var = 2;
var = var + 2; // var is 4

We can also use compound assignments in C++ to apply operations on the variable itself.

We will start with a simple integer declaration

int var = 2;

The following are compound assignment operators:

Operator	Example
`+=`	`var += 3;` Add 3 to variable `var` The value of `var` is now 5
`-=`	`var -= 3;` Subtract 3 from variable `var` The value of `var` is now -1
`*=`	`var *= 3;` Multiply `var` by 3 The value of `var` is now 6.
`/=`	`var /= 2;` Divide 2 by `var` The value of `var` is now 1.

# Increment & Decrement

Incrementing means adding 1 to a variable and decrementing is subtracting by 1. We can do this simply with the basic operators that we have learned:

int var = 2;
var = var + 1; // var is 3

However we can also use the increment and decrement operators:

Operator	Example
`++`	`var++;` Increment `var` The value of `var` is now 3
`--`	`var--;` Decrement `var` The value of `var` is now 1

Homework

Modify the program below to increment var at every loop iteration before printing the value of var.

← Variables Relational Operations →